/**
 * ICS文件解析工具
 */

/**
 * 解析ICS文件内容
 * @param {string} icsContent - ICS文件内容
 * @returns {Array} 解析后的课程列表
 */
export function parseICS(icsContent) {
	if (!icsContent || typeof icsContent !== 'string') {
		throw new Error('ICS文件内容无效')
	}
	
	// 验证ICS文件格式
	if (!icsContent.includes('BEGIN:VCALENDAR') || !icsContent.includes('END:VCALENDAR')) {
		throw new Error('无效的ICS文件格式')
	}
	
	const events = []
	const lines = icsContent.split('\n').map(line => line.trim())
	
	let currentEvent = null
	let isInEvent = false
	let isInAlarm = false
	
	for (let i = 0; i < lines.length; i++) {
		const line = lines[i]
		
		if (line === 'BEGIN:VEVENT') {
			isInEvent = true
			currentEvent = {}
		} else if (line === 'END:VEVENT' && isInEvent) {
			isInEvent = false
			if (currentEvent && currentEvent.summary) {
				events.push(processEvent(currentEvent))
			}
			currentEvent = null
		} else if (line === 'BEGIN:VALARM') {
			isInAlarm = true
		} else if (line === 'END:VALARM') {
			isInAlarm = false
		} else if (isInEvent && !isInAlarm && line.includes(':')) {
			const colonIndex = line.indexOf(':')
			const property = line.substring(0, colonIndex)
			const value = line.substring(colonIndex + 1)
			
			switch (property) {
				case 'SUMMARY':
					currentEvent.summary = value
					break
				case 'DESCRIPTION':
					currentEvent.description = value
					break
				case 'LOCATION':
					currentEvent.location = value
					break
				case 'DTSTART':
					currentEvent.startTime = parseDateTime(value)
					break
				case 'DTEND':
					currentEvent.endTime = parseDateTime(value)
					break
				case 'UID':
					currentEvent.uid = value
					break
				case 'SEQUENCE':
					currentEvent.sequence = parseInt(value) || 0
					break
			}
		}
	}
	
	if (events.length === 0) {
		throw new Error('未找到有效的课程事件')
	}
	
	return events
}

/**
 * 处理单个事件，提取课程信息
 * @param {Object} event - 原始事件对象
 * @returns {Object} 处理后的课程对象
 */
function processEvent(event) {
	// 优化教师信息提取
	const teacher = extractTeacherInfo(event.description || '')
	
	// 计算课程时长（分钟）
	const duration = event.startTime && event.endTime 
		? Math.round((event.endTime.getTime() - event.startTime.getTime()) / (1000 * 60))
		: 0
	
	// 清理课程名称
	const title = cleanCourseTitle(event.summary || '')
	
	return {
		id: event.uid || generateId(),
		title: title,
		teacher: teacher,
		location: event.location || '',
		startTime: event.startTime,
		endTime: event.endTime,
		duration: duration,
		weekday: event.startTime ? event.startTime.getDay() : 0, // 0=周日, 1=周一...
		timeSlot: getTimeSlot(event.startTime),
		color: getSubjectColor(title),
		sequence: event.sequence || 0
	}
}

/**
 * 提取教师信息
 * @param {string} description - 事件描述
 * @returns {string} 教师姓名
 */
function extractTeacherInfo(description) {
	if (!description) return ''
	
	// 匹配各种教师格式：
	// 1. "教师: 廖全"
	// 2. "教师: 范海群-Y0681[主讲]\;"
	// 3. "教师: 罗勇-Y0651[主讲]\;"
	const patterns = [
		/教师:\s*([^-\[\n\r]+)(?:-[^[\n\r]*)?(?:\[[^\]]*\])?/,
		/教师:\s*(.+?)(?:\s*-\s*[A-Z]\d+)?(?:\s*\[[^\]]*\])?(?:\s*\\?;?)?$/,
		/教师:\s*(.+)/
	]
	
	for (const pattern of patterns) {
		const match = description.match(pattern)
		if (match && match[1]) {
			// 清理教师姓名
			let teacher = match[1].trim()
			// 移除末尾的特殊字符
			teacher = teacher.replace(/[\\;]+$/, '').trim()
			if (teacher) {
				return teacher
			}
		}
	}
	
	return ''
}

/**
 * 清理课程名称
 * @param {string} title - 原始课程名称
 * @returns {string} 清理后的课程名称
 */
function cleanCourseTitle(title) {
	if (!title) return ''
	
	// 移除可能的编号或代码
	return title.trim()
}

/**
 * 解析日期时间字符串，支持UTC时间转换
 * @param {string} dateTimeString - 格式如 20250912T062500Z
 * @returns {Date} 解析后的Date对象
 */
function parseDateTime(dateTimeString) {
	if (!dateTimeString) return null
	
	// 检查是否为UTC时间（以Z结尾）
	const isUTC = dateTimeString.endsWith('Z')
	const cleanStr = dateTimeString.replace('Z', '')
	
	// 解析格式：YYYYMMDDTHHMMSS
	const year = parseInt(cleanStr.substring(0, 4))
	const month = parseInt(cleanStr.substring(4, 6)) - 1 // 月份从0开始
	const day = parseInt(cleanStr.substring(6, 8))
	const hour = parseInt(cleanStr.substring(9, 11))
	const minute = parseInt(cleanStr.substring(11, 13))
	const second = parseInt(cleanStr.substring(13, 15)) || 0
	
	let date
	if (isUTC) {
		// UTC时间，直接当作北京时间（UTC+8）解析
		// 不使用Date.UTC，直接用本地时间构造器，然后调整为北京时间
		date = new Date(year, month, day, hour + 8, minute, second)
	} else {
		// 本地时间
		date = new Date(year, month, day, hour, minute, second)
	}
	
	return date
}

/**
 * 获取时间段标识
 * @param {Date} startTime - 开始时间
 * @returns {string} 时间段标识
 */
function getTimeSlot(startTime) {
	if (!startTime) return ''
	
	const hour = startTime.getHours()
	
	// 根据开始时间确定时间段
	if (hour < 8) return 'early'
	else if (hour < 12) return 'morning'
	else if (hour < 14) return 'noon'
	else if (hour < 18) return 'afternoon'
	else return 'evening'
}

/**
 * 根据课程名称获取颜色
 * @param {string} subject - 课程名称
 * @returns {string} 颜色值
 */
function getSubjectColor(subject) {
	// 扩展的颜色映射表
	const colorMap = {
		'工程设计': '#3B82F6',      // 蓝色
		'数理综合': '#8B5CF6',      // 紫色
		'化学': '#10B981',          // 绿色
		'控制算法': '#F59E0B',      // 橙色
		'马克思主义': '#EF4444',    // 红色
		'人文与自然': '#06B6D4',    // 青色
		'体育': '#84CC16',          // 青绿色
		'形势与政策': '#6366F1',    // 靛蓝色
		'网球': '#F97316',          // 橙红色
		'物理': '#EC4899',          // 粉色
		'英语': '#14B8A6',          // 青绿色
		'计算机': '#7C3AED',        // 紫罗兰色
		'数学': '#DC2626',          // 深红色
		'实验': '#059669'           // 深绿色
	}
	
	// 匹配课程关键词
	for (const [keyword, color] of Object.entries(colorMap)) {
		if (subject.includes(keyword)) {
			return color
		}
	}
	
	// 根据课程名称生成一致的颜色
	return generateConsistentColor(subject)
}

/**
 * 根据字符串生成一致的颜色
 * @param {string} str - 输入字符串
 * @returns {string} 颜色值
 */
function generateConsistentColor(str) {
	const colors = [
		'#3B82F6', '#10B981', '#F59E0B', '#EF4444', 
		'#8B5CF6', '#06B6D4', '#F97316', '#EC4899',
		'#14B8A6', '#7C3AED', '#DC2626', '#059669'
	]
	
	// 简单的哈希函数
	let hash = 0
	for (let i = 0; i < str.length; i++) {
		const char = str.charCodeAt(i)
		hash = ((hash << 5) - hash) + char
		hash = hash & hash // 转换为32位整数
	}
	
	return colors[Math.abs(hash) % colors.length]
}

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
function generateId() {
	return Date.now().toString(36) + Math.random().toString(36).substr(2)
}

/**
 * 按周组织课程数据
 * @param {Array} courses - 课程列表
 * @returns {Object} 按周分组的课程数据
 */
export function organizeCoursesByWeek(courses) {
	const weeks = {}
	
	courses.forEach(course => {
		if (!course.startTime) return
		
		// 获取该课程所在的周
		const weekKey = getWeekKey(course.startTime)
		
		if (!weeks[weekKey]) {
			weeks[weekKey] = {
				weekStart: getWeekStart(course.startTime),
				weekEnd: getWeekEnd(course.startTime),
				courses: {}
			}
		}
		
		// 按星期几分组
		const dayKey = course.weekday
		if (!weeks[weekKey].courses[dayKey]) {
			weeks[weekKey].courses[dayKey] = []
		}
		
		weeks[weekKey].courses[dayKey].push(course)
	})
	
	// 对每天的课程按时间排序
	Object.values(weeks).forEach(week => {
		Object.values(week.courses).forEach(dayCourses => {
			dayCourses.sort((a, b) => a.startTime - b.startTime)
		})
	})
	
	return weeks
}

/**
 * 获取周标识
 * @param {Date} date - 日期
 * @returns {string} 周标识
 */
function getWeekKey(date) {
	const weekStart = getWeekStart(date)
	return `${weekStart.getFullYear()}-W${getWeekNumber(weekStart)}`
}

/**
 * 获取一周的开始日期（周一）
 * @param {Date} date - 任意日期
 * @returns {Date} 该周的周一
 */
function getWeekStart(date) {
	const d = new Date(date)
	const day = d.getDay()
	const diff = d.getDate() - day + (day === 0 ? -6 : 1) // 调整到周一
	return new Date(d.setDate(diff))
}

/**
 * 获取一周的结束日期（周日）
 * @param {Date} date - 任意日期
 * @returns {Date} 该周的周日
 */
function getWeekEnd(date) {
	const weekStart = getWeekStart(date)
	const weekEnd = new Date(weekStart)
	weekEnd.setDate(weekStart.getDate() + 6)
	return weekEnd
}

/**
 * 获取周数
 * @param {Date} date - 日期
 * @returns {number} 周数
 */
function getWeekNumber(date) {
	const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()))
	const dayNum = d.getUTCDay() || 7
	d.setUTCDate(d.getUTCDate() + 4 - dayNum)
	const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1))
	return Math.ceil((((d - yearStart) / 86400000) + 1) / 7)
}

/**
 * 格式化时间显示
 * @param {Date} date - 日期时间
 * @returns {string} 格式化后的时间字符串
 */
export function formatTime(date) {
	if (!date) return ''
	
	const hour = date.getHours().toString().padStart(2, '0')
	const minute = date.getMinutes().toString().padStart(2, '0')
	
	return `${hour}:${minute}`
}

/**
 * 格式化日期显示
 * @param {Date} date - 日期
 * @returns {string} 格式化后的日期字符串
 */
export function formatDate(date) {
	if (!date) return ''
	
	const month = (date.getMonth() + 1).toString().padStart(2, '0')
	const day = date.getDate().toString().padStart(2, '0')
	
	return `${month}/${day}`
}

/**
 * 获取星期几的中文名称
 * @param {number} weekday - 星期几 (0=周日, 1=周一...)
 * @returns {string} 中文名称
 */
export function getWeekdayName(weekday) {
	const names = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
	return names[weekday] || ''
} 